﻿// ---------------------------------------------------------------------------------------------------------------------
//   Copyright (c) SRT Solutions 2009. All rights reserved.
// ---------------------------------------------------------------------------------------------------------------------

namespace SRTSolutions.Elevate
{
	using global::System.ComponentModel;
	using global::System.Collections.Generic;

    /// <summary>
    /// Contains methods for generating sequences (IEnumerables)
    /// </summary>
    [Browsable(false)]
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static partial class Seq
    {
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(params T[] args)
        {
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(T value00, T value01, T value02, T value03, IEnumerable<T> enumerable0, T value10, T value11, T value12, T value13, IEnumerable<T> enumerable1, T value20, T value21, T value22, T value23, params T[] args)
        {
            yield return value00;
            
            yield return value01;
            
            yield return value02;
            
            yield return value03;
            
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            yield return value10;
            
            yield return value11;
            
            yield return value12;
            
            yield return value13;
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            yield return value20;
            
            yield return value21;
            
            yield return value22;
            
            yield return value23;
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, IEnumerable<T> enumerable3, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach( var value in enumerable3)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, IEnumerable<T> enumerable3, IEnumerable<T> enumerable4, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach( var value in enumerable3)
            {
                yield return value;
            }
            
            foreach( var value in enumerable4)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, IEnumerable<T> enumerable3, IEnumerable<T> enumerable4, IEnumerable<T> enumerable5, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach( var value in enumerable3)
            {
                yield return value;
            }
            
            foreach( var value in enumerable4)
            {
                yield return value;
            }
            
            foreach( var value in enumerable5)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, IEnumerable<T> enumerable3, IEnumerable<T> enumerable4, IEnumerable<T> enumerable5, IEnumerable<T> enumerable6, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach( var value in enumerable3)
            {
                yield return value;
            }
            
            foreach( var value in enumerable4)
            {
                yield return value;
            }
            
            foreach( var value in enumerable5)
            {
                yield return value;
            }
            
            foreach( var value in enumerable6)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, IEnumerable<T> enumerable3, IEnumerable<T> enumerable4, IEnumerable<T> enumerable5, IEnumerable<T> enumerable6, IEnumerable<T> enumerable7, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach( var value in enumerable3)
            {
                yield return value;
            }
            
            foreach( var value in enumerable4)
            {
                yield return value;
            }
            
            foreach( var value in enumerable5)
            {
                yield return value;
            }
            
            foreach( var value in enumerable6)
            {
                yield return value;
            }
            
            foreach( var value in enumerable7)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, IEnumerable<T> enumerable3, IEnumerable<T> enumerable4, IEnumerable<T> enumerable5, IEnumerable<T> enumerable6, IEnumerable<T> enumerable7, IEnumerable<T> enumerable8, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach( var value in enumerable3)
            {
                yield return value;
            }
            
            foreach( var value in enumerable4)
            {
                yield return value;
            }
            
            foreach( var value in enumerable5)
            {
                yield return value;
            }
            
            foreach( var value in enumerable6)
            {
                yield return value;
            }
            
            foreach( var value in enumerable7)
            {
                yield return value;
            }
            
            foreach( var value in enumerable8)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
        /// <summary>
        /// Generates a sequence from a set of values or enumerations.
        /// </summary>
        public static IEnumerable<T> Build<T>(IEnumerable<T> enumerable0, IEnumerable<T> enumerable1, IEnumerable<T> enumerable2, IEnumerable<T> enumerable3, IEnumerable<T> enumerable4, IEnumerable<T> enumerable5, IEnumerable<T> enumerable6, IEnumerable<T> enumerable7, IEnumerable<T> enumerable8, IEnumerable<T> enumerable9, params T[] args)
        {
            foreach( var value in enumerable0)
            {
                yield return value;
            }
            
            foreach( var value in enumerable1)
            {
                yield return value;
            }
            
            foreach( var value in enumerable2)
            {
                yield return value;
            }
            
            foreach( var value in enumerable3)
            {
                yield return value;
            }
            
            foreach( var value in enumerable4)
            {
                yield return value;
            }
            
            foreach( var value in enumerable5)
            {
                yield return value;
            }
            
            foreach( var value in enumerable6)
            {
                yield return value;
            }
            
            foreach( var value in enumerable7)
            {
                yield return value;
            }
            
            foreach( var value in enumerable8)
            {
                yield return value;
            }
            
            foreach( var value in enumerable9)
            {
                yield return value;
            }
            
            foreach(var item in args)
            {
                yield return item;
            }
        }
        
            }
}

